Bug: AsyncHttpTransport Event Loop Handling Errors

The AsyncHttpTransport.capture_envelope method has two event loop handling issues:

1. It incorrectly uses asyncio.create_task on the current thread's running loop, which may not be self.loop, causing tasks to run on an unintended event loop.
2. A race condition exists where self.loop.is_running() can be true, but the loop stops before asyncio.run_coroutine_threadsafe() is called, leading to a RuntimeError.

_create_worker in the shared class should be NotImplemented while the respective sync and async classes should implement only their own version.

nit on writing good nested/multiple conditionals, each branch should only be responsible for its own logic, so a bit cleaner the other way around

    transport_cls = Http2Transport if use_http2_transport else HttpTransport
    if use_async_transport:
        try:
            asyncio.get_running_loop()
            transport_cls: Type[Transport] = AsyncHttpTransport
        except RuntimeError:
            # No event loop running, fall back to sync transport
            logger.warning("No event loop running, falling back to sync transport.")

Refactored it :)

let's gather all the required warnings in one place, so move this logger statement and check to make_transport below and then this can just become

AsyncHttpTransport = BaseHttpTransport

Done!

Bug: Async Transport Flush Issues

The AsyncHttpTransport.flush() method submits an unawaited coroutine to the AsyncWorker by calling the async _flush_client_reports method within a synchronous lambda. This prevents client reports from being flushed and may cause runtime warnings.

Furthermore, the AsyncHttpTransport.background_tasks set is initialized but never populated, rendering the task cancellation logic in kill() ineffective.

Lastly, AsyncHttpTransport.flush() changes its return type from None (in BaseHttpTransport) to Optional[asyncio.Task[None]], breaking the interface contract and potentially indicating a type mismatch with _worker.flush.

Bug: Redundant ImportError Handling

The try/except ImportError block for ASYNC_TRANSPORT_ENABLED is redundant. The httpcore module's availability is already determined before this block, so the expression httpcore is not None cannot raise an ImportError. This makes the except clause unreachable dead code.

Bug: AsyncHttpTransport Kill Method Fails Resource Cleanup

The AsyncHttpTransport's kill() method has two main problems:

1. Incomplete Resource Cleanup: The background_tasks set, intended for tracking, is never populated, rendering the task cancellation logic ineffective. Additionally, the _pool.aclose() task created by kill() is not tracked, potentially causing resource leaks if not explicitly awaited by the caller.
2. Interface Violation: The method's return type is changed from None (as defined in the base Transport interface) to Optional[asyncio.Task[None]], violating the Liskov Substitution Principle.

I will remove the background task set, it should not be necessary anymore I think

Bug: Async Method Not Awaited Causes Flush Failure

The AsyncHttpTransport.flush method submits a synchronous lambda to the worker that calls the async _flush_client_reports method without awaiting it. This results in a coroutine object being submitted instead of the function executing, preventing client reports from being flushed. The correct pattern, as seen in _capture_envelope, is to use an async wrapper.

Bug: Redundant Import Handling in Async Transport

The try/except ImportError block around ASYNC_TRANSPORT_ENABLED = httpcore is not None is redundant. No import statement exists within the try block, rendering the except ImportError clause unreachable dead code. The ASYNC_TRANSPORT_ENABLED flag is simply assigned based on the prior import status of httpcore, making the try/except structure unnecessary and misleading.

think this does not need to be async def anymore and can be moved to shared?

merging it in, we will take care of this when we do the mixin

This is async because otherwise the worker process_callback needs the case distinction between coroutines and sync functions.

See:

#4591 (comment)
#4614 (comment)